System Synthesis from a Monadic Functional Language

Embedded systems typically combine a mixture of heterogeneous components, some that are software executing on general purpose CPUs, some that are off-the-shelf hardware components, and some that are application specific circuitry. A major challenge when designing and implementing such systems is the dissimilar models of computation exhibited by hardware and software targets. To successfully navigate this challenge, components must be implemented in a way that does not unnecessarily bias the implementation towards either computational model, allowing the components to be retargeted as application requirements change. This dissertation presents an approach to this problem using a functional programming language extended with monadic imperative and concurrency effects. We argue that these language features allow components to be implemented and compiled to either hardware or software targets. To demonstrate this claim, we detail the design of such a language, Oread. Moreover, we describe the compilation of Oread to both hardware, via VHDL, and software, via C. Using these compilation techniques, we describe the development of a digital processing component in Oread and the integration of that component into a larger system

Type Preservation as a Confluence Problem

This paper begins with recent work by Kuan, MacQueen, and Findler, which shows how standard type systems, such as the simply typed lambda calculus, can be viewed as abstract reduction systems operating on terms. The central idea is to think of the process of typing a term as the computation of an abstract value for that term. The standard metatheoretic property of type preservation can then be seen as a confluence problem involving the concrete and abstract operational semantics, viewed as abstract reduction systems (ARSs). In this paper, we build on the work of Kuan et al. by showing show how modern ARS theory, in particular the theory of decreasing diagrams, can be used to establish type preservation via confluence. We illustrate this idea through several examples of solving such problems using decreasing diagrams. We also consider how automated tools for analysis of term-rewriting systems can be applied in testing typ

Step-Indexed Normalization for a Language with General Recursion

The Trellys project has produced several designs for practical dependently typed languages. These languages are broken into two fragments-a_logical_fragment where every term normalizes and which is consistent when interpreted as a logic, and a_programmatic_fragment with general recursion and other convenient but unsound features. In this paper, we present a small example language in this style. Our design allows the programmer to explicitly mention and pass information between the two fragments. We show that this feature substantially complicates the metatheory and present a new technique, combining the traditional Girard-Tait method with step-indexed logical relations, which we use to show normalization for the logical fragment.Comment: In Proceedings MSFP 2012, arXiv:1202.240

Prufrock: A Framework for Constructing Polytypic Theorem Provers

Current formal software engineering methodologies provide a vast array of languages for specifying correctness properties, as well as a wide assortment automated tools that aid in the verification of specified properties. Unfortunately, the implementation of each such tool requires an early commitment to a particular methodology and language, in terms of both high-level semantic concerns and the lower-level syntactic representations of properties and proofs. In this paper, we present Prufrock, a novel approach to automated reasoning systems, which abstracts semantic concerns over entire classes of potential implementation languages. Prufrock is a modular prover framework written in the Haskell programming language. It consists of a set of largely independent logic modules, which define the semantics required for proof over entire classes of abstract syntaxes, using polytypic programming techniques. Any given representation language may be used for specifying and verifying properties in Prufrock, so long as it provides a semantics consistent with the logic modules that required for a proof. The implementation details of the reasoning system thus remain independent of the structure specification language, facilitating large-scale reuse in the construction of automated reasoning tools. At the same time, Prufrock aids in closing the gap between actual source-level implementation and the formal specification and verification of correctness properties. This paper provides an overview of the major design philosophy behind Prufrock, as well as a brief description of the polytypic techniques that make its implementation possible. 1

The University of Kansas Composing Specifications Using Algebra Combinators

Project Sponsor: National Science Foundation The need to understand effects of cross-cutting concerns defines the essence of systems-level design. Understanding the impacts of local design decisions on global requirements such as power consumption or security is mandatory for constructing correct systems. Unfortunately, domain specific models may be defined using different semantics making analysis difficulty. We define an algebra combinator that provide semantics for syntax, an algebra combinator defines a single model that embodies the composition of those specifications. Such composite models can then be used to understand the interaction of models from the original specification domains.

Building compilers by combining algebras

Embedded systems present a wide variety of challenges for developers of language tools. Verification of correctness, flexibility for adding new language features, and retargeting new architectures all present significant problems when developing a compiler for embedded systems. In this paper we present a domain-specific language based on modular monadic semantics which addresses many of these challenges